


1) Peakstat.py

#!/usr/bin/env python
import sys
from optparse import OptionParser
from solexatools import peak_stats
from solexatools.track import SimpleTrack
from os.path import basename,splitext
import os

DEFAULT_BINS = 10
VERSION = "2.1"
usage = "Usage: %prog -p BEDFILE -d DATAFILE [options]\nVersion: " + str(VERSION)

parser = OptionParser(usage=usage, version="%prog " + str(VERSION))
parser.add_option("-p", "--peakfile", dest="peakfile", help="Peaks in BED format", metavar="FILE")
parser.add_option("-d", "--datafile", dest="datafile", help="Data in BAM, BED or WIG format", metavar="FILE")
parser.add_option("-f", "--format", dest="format", help="Output format: all|number|max|mean|sum|maxfeature|length|window", metavar="F", default="all")
parser.add_option("-z", "--zeroes", dest="zeroes", help="Print zeroes", action="store_true", default=False)
parser.add_option("-b", "--bins", dest="bins", help="Number of bins (only when format option 'window' is used)", type="int", default=DEFAULT_BINS)
parser.add_option("--rpkm", dest="rpkm", help="Report RPKM (only with BAM datafile and format option 'window')", default=False, action="store_true")
parser.add_option("--remove_dup", dest="remove_dup", help="Remove duplicates (only with BAM datafile and format option 'window')", default=False, action="store_true")
parser.add_option("--unique", dest="unique", help="Only uniquely mapped reads (only with BAM datafile and format option 'window')", default=False, action="store_true")

(options, args) = parser.parse_args()

if not options.peakfile or not options.datafile:
	parser.print_help()
	sys.exit(1)

peakfile = options.peakfile
datafile = options.datafile
format = options.format

peaks = SimpleTrack(peakfile)

formatter = {
	"all": peak_stats.all_formatter,
	"number": peak_stats.number_formatter,
	"max" : peak_stats.max_formatter,
	"mean" : peak_stats.mean_formatter,
	"maxfeature": peak_stats.maxfeature_formatter,
	"sum": peak_stats.sum_formatter,
	"window": peak_stats.bin_formatter,
	"length": peak_stats.length_formatter,
	"catch": peak_stats.catch_formatter,
}

formatter_options = {"bins":options.bins}


result = []
if datafile.endswith("bam"):
	if not os.path.exists(datafile + ".bai"):
		print "Please provide a sorted and indexed bam file"
		sys.exit(1)
	if options.format =="window":
		result = peak_stats.bam_binned_peak_stats(peaks, datafile, options.bins, options.rpkm, options.remove_dup, options.unique)
	else:
		result = peak_stats.bam_peak_stats(peaks, datafile, formatter[format], formatter_options)

else:
	data = SimpleTrack(datafile)
	result = peak_stats.peak_stats(peaks, data, formatter[format], formatter_options)

if options.format == "window" and options.bins == DEFAULT_BINS:
	sys.stderr.write("Using default of %d bins, optionally specify a different bin number with the -b option\n" % options.bins)

if format == "catch":
	name = splitext(basename(datafile))[0]
	print "## %s" % name
	print "## %s" % name

for row in result:
	if row:
		print row



########################################################


2) coverage_profile.py

#!/usr/bin/env python
from numpy import *
import sys
from optparse import OptionParser,TitledHelpFormatter
from solexatools.track import *

VERSION = "1.0"

DEFAULT_POSITION = "middle"

usage = "usage: %prog -f <FILE> -d <FILE> -b <SIZE> -w <LENGTH> [-p POS]"
parser = OptionParser(version=VERSION, usage=usage, formatter=TitledHelpFormatter(max_help_position=40, short_first=1))
parser.add_option("-f", "--featurefile", dest="feature_file", help="GFF formatted file of features (NO BED format!)", metavar="FILE")
parser.add_option("-d", "--datafile", dest="data_file", help="BED formatted datafile (NO WIG or GFF format!)", metavar="FILE")
parser.add_option("-w", "--window", dest="window", help="Window length", metavar="LENGTH")
parser.add_option("-b", "--bin", dest="bin", help="Bin size", metavar="SIZE")
parser.add_option("-p", "--position", dest="position", help="Position of feature to consider: start, end or middle (strand is taken into account, default is middle)", metavar="POS", default=DEFAULT_POSITION)

(options, args) = parser.parse_args()

if not options.feature_file or not options.data_file or not options.window or not options.bin:
	parser.print_help()
	sys.exit(0)

data_file = options.data_file
feature_file = options.feature_file
bin = int(options.bin)
window = int(options.window)
position = options.position	

# Speed up reading of large files
BUFSIZE = 10000000

# Dict to store all features per chromosome
pos = {}

# Read file of data points (only start & end are used)
t = SimpleTrack(data_file)
f = t.get_next_feature()
while f:
	if not(pos.has_key(f[0])):
		pos[f[0]] = []
	pos[f[0]].append([f[1],f[2] + 1])
	f = t.get_next_feature()

# Transform lists to Numpy arrays
for chr in pos.keys():
	pos[chr] = array(pos[chr])

# Array containing all the bins
bins = arange(-window, window, bin)

# Read the whole file at once
f = open(feature_file)
lines = f.readlines()
f.close()

# Array to store results
result = array(zeros((len(lines), len(bins))), dtype=int32)

c = 0
for line in lines:
	vals = line[:-1].split("\t")
	strand = vals[6]
	if strand == "-1":
		strand = "-"
	chr = vals[0]
	middle = 0
	if (position == "start" and strand == "-") or (position == "end" and strand == "+"):
		middle = int(vals[4])
	elif (position == "end" and strand == "-") or (position == "start" and strand == "+"):
		middle = int(vals[3])
	else:
		middle = (int(vals[4]) + int(vals[3])) / 2
	
	# Get all data points within window range of the feature to minimize amount of calculations (and use less memory)
	if not(pos.has_key(chr)):
		in_range = []
	else:
		in_range = pos[chr][pos[chr][:,1] >= middle - window]
	if len(in_range) > 0:
		in_range = in_range[in_range[:,0] <= middle + window]

	if len(in_range) > 0:
		# Define matrices
		(f_start, b_start) = ix_(in_range[:,0], bins + middle)
		(f_end, b_end) = ix_(in_range[:,1], bins + middle + bin)
	
		# Calculate overlap
		overlap = maximum(f_end, b_end) -  minimum(f_start, b_start) - abs(b_start - f_start) - abs(b_end - f_end)
		overlap[overlap < 0] = 0
	
		# Take care of minus strands
		if vals[6] == "-" or vals[6] == "-1":
			result[c] = overlap.sum(0)[::-1]
		else:
			result[c] = overlap.sum(0)
		c += 1
	else:
		result[c] = array(zeros((len(bins))))

pos = -window

for i in range(len(result[0])):
	d = result[:,i]
	#print "%s\t%0.2f\t%0.2f\t%0.2f\t%s" % (pos, mean(d), std(d), median(d), len(d))
	print "%s\t%0.2e" % (pos, mean(d))
	pos += bin

#for mean_val, median_val in zip(result.mean(0), median(result)):
#	print "%s\t%si\t%s" % (pos, mean_val, median_val)
#	pos += bin





###################### RFP analysis

zcat $file | fastx_clipper  -Q33 -a CTGTAGGCACCATCAAT -l 25 -c -n -v 
zcat $file | fastx_trimmer -Q33 -f 2   > file
gunzip -c $file | bowtie --seedlen=23 --un "$file".cleaned --al "$file".alligned Total_tRNA_rRNA_snRNA_snoRNA_mtrRNA_mttRNA /dev/stdin >/dev/null 
gsnap -d mm9 -D /mnt/MD3200v2p1/gmap-2014-07-28/share -A sam -B 5 -t 15 -N 1 -E 100 -w 100000 -n 10 --split-output="$file"_gsnap2014  -s mm9refGene_splice $file
htseq-count -m union -s reverse -t CDS  $file Ensemble_Mus_musculus.NCBIM37.67.gtf  > "$file".htseqcount



###################### Hypergeometric test


library(openxlsx)
library(gmp)
library(stringr)
library(pheatmap)
library(RColorBrewer)

rm(list=ls())

adjust.mt <- T

n.genes <- 14800

embryo <- read.xlsx("2_smith_embryo_clusters.xlsx", colNames = T)
clust <- read.xlsx("1_2i_SL_EPI_clusters.xlsx", colNames = T)



# enrichment value of 2 overlapping lists
enrich_pvalue <- function(N, A, B, k)
{
  m <- A + k
  n <- B + k
  i <- k:min(m,n)
  
  as.numeric( sum(chooseZ(m,i)*chooseZ(N-m,n-i))/chooseZ(N,n) )
}


overlap <- matrix(NA, nrow=ncol(embryo), ncol=ncol(clust))
enrich <-  matrix(NA, nrow=ncol(embryo), ncol=ncol(clust))

for(i in 1:ncol(embryo))
{
  for(j in 1:ncol(clust))
  {
    overlap[i,j] <- sum(str_trim(tolower(na.omit(embryo[,i]))) %in% str_trim(tolower(na.omit(clust[,j]))))
    enrich[i,j] <- enrich_pvalue(N=n.genes, A=length(na.omit(embryo[,i]))-overlap[i,j], B=length(na.omit(clust[,j]))-overlap[i,j], k=overlap[i,j])    
  }
}



col <- colorRampPalette(brewer.pal(n=9, name="Reds"))(500)
col[1] <- "#FFFFFF"

if (adjust.mt)
{
  enrich.after <- matrix(p.adjust(enrich, "BH"), nrow=nrow(enrich))
  enrich <- -log10(enrich.after)
  f.name <- "esc_stages_after_correction.pdf"
} else
{
  enrich.before <- enrich
  enrich <- -log10(enrich.before)  
  f.name <- "esc_stages_before_correction.pdf"
}



colnames(enrich) <- colnames(clust)
rownames(enrich) <- colnames(embryo)

pheatmap(enrich, color = col,  cluster_rows = F, cluster_cols = F, cellwidth = 35, cellheight = 35)#, filename = f.name)

dev.off()

